import axios from "axios";
import { Local, Session } from "@/utils/storage";
import { createDiscreteApi } from "naive-ui";
import { getErrorMessage } from "@/utils/errorMessageHanler";
import bus from "@/utils/mitt";

const { message, notification } = createDiscreteApi(
  ["message", "notification"],
  {}
);

// 配置新建一个 axios 实例
export const service = axios.create({
  baseURL: window.API_URL, // import.meta.env.VITE_API_URL,
  timeout: 90000,
  headers: {
    "Content-Type": "application/json",
  },
});
// token 键定义
export const accessTokenKey = "access-token";
export const refreshAccessTokenKey = `x-${accessTokenKey}`;

// 获取 token
export const getToken = () => {
  return Local.get(accessTokenKey);
};
export const setToken = (token) => {
  return Local.set(accessTokenKey, token);
};

// 清除 token
export const clearAccessTokens = () => {
  Local.remove(accessTokenKey);
  Local.remove(refreshAccessTokenKey);
  // 清除其他
  Session.clear();
  // window.location.href = "/#/login";
  // 刷新浏览器
  // window.location.reload();
};

// axios 默认实例
export const axiosInstance = axios;

// 添加请求拦截器
service.interceptors.request.use(
  (config) => {
    // 获取本地的 token
    const accessToken = Local.get(accessTokenKey);
    if (accessToken) {
      if (!config.withoutToken) {
        // 将 token 添加到请求报文头中
        config.headers["Authorization"] = `Bearer ${accessToken}`;

        //后端没有刷新token
        // // 判断 accessToken 是否过期
        // const jwt = decryptJWT(accessToken);
        // const exp = getJWTDate(jwt.exp);

        // // token 已经过期
        // if (new Date() >= exp) {
        //   // 获取刷新 token
        //   const refreshAccessToken = Local.get(refreshAccessTokenKey);
        //   // 携带刷新 token
        //   if (refreshAccessToken) {
        //     config.headers["X-Authorization"] = `Bearer ${refreshAccessToken}`;
        //   }
        // }
      }
      // debugger
      // get请求映射params参数
      if (config.method?.toLowerCase() === "get" && config.data) {
        let url = config.url + "?" + tansParams(config.data);
        url = url.slice(0, -1);
        config.data = {};
        config.url = url;
      }
    }

    return config;
  },
  (error) => {
    // 对请求错误做些什么
    return Promise.reject(error);
  }
);

// 添加响应拦截器
service.interceptors.response.use(
  (res) => {
    // 获取状态码和返回数据
    var serve = res.data;
    if (serve.code == 200 && serve.data === false) {
      // notification.error({
      //   content: "Error",
      //   meta: getErrorMessage("none"),
      //   duration: 2500,
      //   keepAliveOnHover: true,
      // });
      console.error("%c Line:101 🥕", "color:#ea7e5c");
      return;
    }

    if (
      ["SecurityEnum.EXPIRED_TOKEN", "SecurityEnum.UNAUTHORIZED"].includes(
        serve.message
      )
    ) {
      //token 过期
      clearAccessTokens();
      //路由跳转过来的  直接显示登录框
      bus.emit("showLoginDialog");

      console.error("%c Line:112 🍻", "color:#b03734", serve.message);
      return;
    }

    // notification.error({
    //   content: "Error",
    //   meta: getErrorMessage(serve.message),
    //   duration: 2500,
    //   keepAliveOnHover: true,
    // });

    // // 处理未进行规范化处理的
    // if (status >= 400) {
    //   throw new Error(res.statusText || "Request Error.");
    // }

    // // 处理规范化结果错误
    // if (serve && serve.hasOwnProperty("errors") && serve.errors) {
    //   throw new Error(JSON.stringify(serve.errors || "Request Error."));
    // }

    // 读取响应报文头 token 信息
    var accessToken = res.headers[accessTokenKey];
    var refreshAccessToken = res.headers[refreshAccessTokenKey];

    // 判断是否是无效 token
    if (accessToken === "invalid_token") {
      clearAccessTokens();
    }
    // 判断是否存在刷新 token，如果存在则存储在本地
    else if (
      refreshAccessToken &&
      accessToken &&
      accessToken !== "invalid_token"
    ) {
      Local.set(accessTokenKey, accessToken);
      Local.set(refreshAccessTokenKey, refreshAccessToken);
    }

    // 响应拦截及自定义处理
    if (serve.code === 401) {
      clearAccessTokens();
    } else if (serve.code === undefined) {
      return Promise.resolve(res);
    } else if (serve.code !== 200) {
      var message;
      // 判断 serve.message 是否为对象
      if (serve.message && typeof serve.message == "object") {
        message = JSON.stringify(serve.message);
      } else {
        message = serve.message;
      }
      // notification.error({
      //   content: "Error",
      //   meta: message,
      //   duration: 2500,
      //   keepAliveOnHover: true,
      // });

      console.log("%c Line:170 🍤", "color:#b03734", message);
      throw new Error(message);
    }

    return res;
  },
  (error) => {
    // 处理响应错误
    if (error.response) {
      if (error.response.status === 401) {
        clearAccessTokens();
      }
    }

    console.error("%c Line:184 🍢", "color:#2eafb0", error.message);
    // // 对响应错误做点什么
    // if (error.message.indexOf("timeout") != -1) {
    //   notification.error({
    //     content: "Error",
    //     meta: "Tiempo de espera de red excedido.", //网络超时
    //     duration: 2500,
    //     keepAliveOnHover: true,
    //   });
    // } else if (error.message == "Network Error") {
    //   notification.error({
    //     content: "Error",
    //     meta: "Error de conexión a la red", //网络连接错误
    //     duration: 2500,
    //     keepAliveOnHover: true,
    //   });
    // } else {
    //   if (error.response.data)
    //     notification.error({
    //       content: "错误",
    //       meta: error.response.statusText,
    //       duration: 2500,
    //       keepAliveOnHover: true,
    //     });
    //   else
    //     notification.error({
    //       content: "Error",
    //       meta: "No se puede encontrar la ruta de la interfaz", //接口路径找不到
    //       duration: 2500,
    //       keepAliveOnHover: true,
    //     });
    // }

    return Promise.reject(error);
  }
);

/**
 *  参数处理
 * @param {*} params  参数
 */
export function tansParams(params) {
  let result = "";
  for (const propName of Object.keys(params)) {
    const value = params[propName];
    var part = encodeURIComponent(propName) + "=";
    if (value !== null && value !== "" && typeof value !== "undefined") {
      if (typeof value === "object") {
        for (const key of Object.keys(value)) {
          if (
            value[key] !== null &&
            value[key] !== "" &&
            typeof value[key] !== "undefined"
          ) {
            let params = propName + "[" + key + "]";
            var subPart = encodeURIComponent(params) + "=";
            result += subPart + encodeURIComponent(value[key]) + "&";
          }
        }
      } else {
        result += part + encodeURIComponent(value) + "&";
      }
    }
  }
  return result;
}

/**
 * 解密 JWT token 的信息
 * @param token jwt token 字符串
 * @returns <any>object
 */
export function decryptJWT(token) {
  token = token.replace(/_/g, "/").replace(/-/g, "+");
  var json = decodeURIComponent(escape(window.atob(token.split(".")[1])));
  return JSON.parse(json);
}

/**
 * 将 JWT 时间戳转换成 Date
 * @description 主要针对 `exp`，`iat`，`nbf`
 * @param timestamp 时间戳
 * @returns Date 对象
 */
export function getJWTDate(timestamp) {
  return new Date(timestamp * 1000);
}

// 导出 axios 实例
export default service;
